package org.dtrd.modules.flup.service.impl;

import cn.hutool.core.collection.CollectionUtil;
import com.baomidou.dynamic.datasource.annotation.DS;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import lombok.extern.slf4j.Slf4j;
import org.dtrd.modules.flup.entity.bean.FlupTemplateDetail;
import org.dtrd.modules.flup.entity.bean.FlupTemplateListInfo;
import org.dtrd.modules.flup.entity.po.DtrdEntRdFlupTemplate;
import org.dtrd.modules.flup.entity.po.DtrdRlFlupProjectRecord;
import org.dtrd.modules.flup.entity.po.DtrdRlFlupTemplateProject;
import org.dtrd.modules.flup.entity.request.FlupTemplateListRequest;
import org.dtrd.modules.flup.mapper.DtrdEntRdFlupTemplateMapper;
import org.dtrd.modules.flup.service.IDtrdEntRdFlupTemplateService;
import org.dtrd.modules.flup.service.IDtrdRlFlupProjectRecordService;
import org.dtrd.modules.flup.service.IDtrdRlFlupTemplateProjectService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.Optional;
import java.util.stream.Collectors;


/**
 * <p>
 * 复诊模版 服务实现类
 * </p>
 *
 * @author QR
 * @since 2021-12-21
 */
@DS("multi-datasource1")
@Service
@Slf4j
public class DtrdEntRdFlupTemplateServiceImpl extends ServiceImpl<DtrdEntRdFlupTemplateMapper, DtrdEntRdFlupTemplate> implements IDtrdEntRdFlupTemplateService {

    @Autowired
    private IDtrdRlFlupTemplateProjectService flupTemplateProjectRlService;
    @Autowired
    private IDtrdRlFlupProjectRecordService flupProjectRecordService;

    @Override
    public List<FlupTemplateListInfo> getFlupTemplateList(FlupTemplateListRequest request) {
        // 当机构查询不为空的时候，查询全表，当机构查询不为空时按照机构进行查询。
        LambdaQueryWrapper<DtrdEntRdFlupTemplate> queryWrapper = baseQueryWrapper()
                .eq( !StringUtils.isBlank(request.getOrgCode()) ,DtrdEntRdFlupTemplate::getOrgCode, request.getOrgCode())
                .orderByDesc(DtrdEntRdFlupTemplate::getCreateTime);
        List<DtrdEntRdFlupTemplate> poList = list(queryWrapper);
        List<FlupTemplateListInfo> dtoList = new ArrayList<>(poList.size());
        if (!poList.isEmpty()) {
            dtoList = poList.stream().map(FlupTemplateListInfo::new).collect(Collectors.toList());
        }
        return dtoList;
    }

    @Override
    public boolean saveOrUpdateFlupTemplate(FlupTemplateDetail dto) {
        DtrdEntRdFlupTemplate dtrdEntRdFlupTemplate = new DtrdEntRdFlupTemplate();
        if (dto.getDataId() == null) {
            dtrdEntRdFlupTemplate = dtrdEntRdFlupTemplate.init();
        } else {
            LambdaQueryWrapper<DtrdRlFlupProjectRecord> wrapper = Wrappers.lambdaQuery(DtrdRlFlupProjectRecord.class)
                    .eq(DtrdRlFlupProjectRecord::getTemplateId, dto.getDataId());
            List<DtrdRlFlupProjectRecord> records = flupProjectRecordService.list(wrapper);
            if (CollectionUtil.isNotEmpty(records)) {
                for (DtrdRlFlupProjectRecord record : records) {
                    record.setTemplateName(dto.getTemplateName());
                }
                flupProjectRecordService.updateBatchById(records);
            }
        }
        dtrdEntRdFlupTemplate.parseFromDto(dto);
        return saveOrUpdate(dtrdEntRdFlupTemplate);
    }

    @Override
    public boolean removeFlupTemplate(Integer templateId) {
        // 删除复诊模版和项目关系表中的记录
        baseMapper.clearTemplate(templateId);
        // 删除复诊模板表中的记录
        return removeById(templateId);
    }

    @Override
    public boolean isInValidTemplateName(String templateName, Integer templateId, String orgCode) {
        LambdaQueryWrapper<DtrdEntRdFlupTemplate> queryWrapper = Wrappers.lambdaQuery(DtrdEntRdFlupTemplate.class)
                .eq(DtrdEntRdFlupTemplate::getTemplateName, templateName)
                .eq(DtrdEntRdFlupTemplate::getOrgCode, orgCode);
        DtrdEntRdFlupTemplate template = this.getOne(queryWrapper);
        return template != null && !Objects.equals(template.getDataId(), templateId);
    }

    @Override
    public boolean saveFlupTemplateProject(Integer templateId, List<Integer> projectIds) {
        // 删掉原来的记录
//        baseMapper.clearTemplate(templateId);
        // 保存新的记录
        List<DtrdRlFlupTemplateProject> newRelations = new ArrayList<>(projectIds.size());
        projectIds.stream().map(projectId -> new DtrdRlFlupTemplateProject(templateId, projectId)).forEach(newRelations::add);
        log.info("DtrdEntRdFlupTemplateServiceImpl.saveFlupTemplateProject.[templateId, projectIds] newRelations=" + newRelations);
        return flupTemplateProjectRlService.saveBatch(newRelations);
    }

    @Override
    public String getTemplateName(Integer templateId) {
        DtrdEntRdFlupTemplate template = getById(templateId);
        return Optional.ofNullable(template)
                .map(DtrdEntRdFlupTemplate::getTemplateName)
                .orElse(null);
    }

    private LambdaQueryWrapper<DtrdEntRdFlupTemplate> baseQueryWrapper() {
        return Wrappers.lambdaQuery(DtrdEntRdFlupTemplate.class)
                .eq(DtrdEntRdFlupTemplate::getIsDel, 0);
    }

    private LambdaUpdateWrapper<DtrdEntRdFlupTemplate> baseUpdateWrapper() {
        return Wrappers.lambdaUpdate(DtrdEntRdFlupTemplate.class)
                .eq(DtrdEntRdFlupTemplate::getIsDel, 0);
    }
}
